package cn.iocoder.an.module.mold.service.rechecktask;

import cn.iocoder.an.framework.common.pojo.PageResult;
import cn.iocoder.an.module.mold.controller.admin.rechecktask2item.vo.RecheckTask2itemSaveReqVO;
import cn.iocoder.an.module.mold.controller.admin.upkeeptask.vo.UpkeepTaskPageReqVO;
import cn.iocoder.an.module.mold.dal.dataobject.rechecktask.RecheckTaskDO;
import cn.iocoder.an.module.mold.dal.dataobject.rechecktask2item.RecheckTask2itemDO;
import cn.iocoder.an.module.mold.dal.dataobject.rechecktobe.RecheckTobeDO;
import cn.iocoder.an.module.mold.dal.dataobject.upkeeptask.UpkeepTaskDO;
import cn.iocoder.an.module.mold.dal.mysql.rechecktask2item.RecheckTask2itemMapper;
import cn.iocoder.an.module.mold.dal.mysql.rechecktobe.RecheckTobeMapper;
import cn.iocoder.an.module.system.dal.dataobject.user.AdminUserDO;
import cn.iocoder.an.module.system.service.user.AdminUserService;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import org.springframework.stereotype.Service;
import jakarta.annotation.Resource;
import org.springframework.validation.annotation.Validated;

import java.time.LocalDateTime;
import java.util.*;
import cn.iocoder.an.module.mold.controller.admin.rechecktask.vo.*;
import cn.iocoder.an.framework.common.util.object.BeanUtils;

import cn.iocoder.an.module.mold.dal.mysql.rechecktask.RecheckTaskMapper;

import static cn.iocoder.an.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.iocoder.an.module.mold.enums.ErrorCodeConstants.*;

/**
 * 复检任务 Service 实现类
 *
 * @author ykk
 */
@Service
@Validated
public class RecheckTaskServiceImpl implements RecheckTaskService {

    @Resource
    private RecheckTaskMapper recheckTaskMapper;


    @Resource
    private RecheckTobeMapper recheckTobeMapper;

    @Resource
    private RecheckTask2itemMapper recheckTask2itemMapper;

    @Resource
    private AdminUserService userService;

    @Override
    public Long createRecheckTask(RecheckTaskSaveReqVO createReqVO) {
        // 插入
        RecheckTaskDO recheckTask = BeanUtils.toBean(createReqVO, RecheckTaskDO.class);
        recheckTaskMapper.insert(recheckTask);

        // 返回
        return recheckTask.getId();
    }

    @Override
    public void updateRecheckTask(RecheckTaskSaveReqVO updateReqVO) {
        // 校验存在
        validateRecheckTaskExists(updateReqVO.getId());
        // 更新
        RecheckTaskDO updateObj = BeanUtils.toBean(updateReqVO, RecheckTaskDO.class);
        recheckTaskMapper.updateById(updateObj);
    }

    @Override
    public void deleteRecheckTask(Long id) {
        // 校验存在
        validateRecheckTaskExists(id);
        // 删除
        recheckTaskMapper.deleteById(id);
    }

    @Override
        public void deleteRecheckTaskListByIds(List<Long> ids) {
        // 删除
        recheckTaskMapper.deleteByIds(ids);
        }


    private void validateRecheckTaskExists(Long id) {
        if (recheckTaskMapper.selectById(id) == null) {
            throw exception(RECHECK_TASK_NOT_EXISTS);
        }
    }

    @Override
    public RecheckTaskDO getRecheckTask(Long id) {
        return recheckTaskMapper.selectById(id);
    }

    @Override
    public PageResult<RecheckTaskDO> getRecheckTaskPage(RecheckTaskPageReqVO pageReqVO) {
        return recheckTaskMapper.selectPage(pageReqVO);
    }

    @Override
    public Boolean modStatus(RecheckTaskModStatusVO modStatusVO) {
        Long id = modStatusVO.getId();
        Integer status = modStatusVO.getStatus();
        String data = modStatusVO.getData();

        LocalDateTime now  =    LocalDateTime.now();
        RecheckTaskDO taskDO = recheckTaskMapper.selectById(id);
        Integer taskStatus = taskDO.getStatus();

        RecheckTobeDO recheckTobe = selectRecheckTobeByTaskId(taskDO.getId());
        switch (status) {
            case 3:
                if (taskStatus != 2) {
                    throw exception(UPKEEP_TASK_NO_RECEIVED);
                }
                taskDO.setStatus(status);
                //更新待复检任务中的状态
                recheckTobe.setStatus(status);
                recheckTobeMapper.updateById(recheckTobe);

                taskDO.setTaskReceiveTime(now);
                recheckTaskMapper.updateById(taskDO);
                break;
            case 4:
                if (taskStatus != 3&& taskStatus !=5 ) {
                    throw exception(UPKEEP_TASK_NO_START);
                }
                taskDO.setStatus(status);
                //更新待复检任务中的状态
                recheckTobe.setStatus(status);
                recheckTobeMapper.updateById(recheckTobe);
                taskDO.setJobStartTime(now);
                taskDO.setTaskStartTime(LocalDateTime.now());
                recheckTaskMapper.updateById(taskDO);
                break;
            case 5:
                if (taskStatus != 3) {
                    throw exception(UPKEEP_TASK_NO_FINISH);
                }
                taskDO.setStatus(status);
                //更新待复检任务中的状态
                recheckTobe.setStatus(status);
                recheckTobeMapper.updateById(recheckTobe);
                recheckTaskMapper.updateById(taskDO);
                break;
            default:
                throw exception(UPKEEP_TASK_STATUS_ERROR);
        }

        return true;
    }


    @Override
    public Boolean workreport(RecheckTaskWorkReportVO workReportVO) {
        RecheckTaskDO taskDO = recheckTaskMapper.selectById(workReportVO.getId());
        //更新项目
        List<RecheckTask2itemSaveReqVO>  items = workReportVO.getRecheckItems();
        //这里需要先删除task2item
        recheckTask2itemMapper.delete(new LambdaQueryWrapper<RecheckTask2itemDO>()
                .eq(RecheckTask2itemDO::getTaskId, taskDO.getId()));
        //循环插入items
        for (RecheckTask2itemSaveReqVO item : items) {
            recheckTask2itemMapper.insert(BeanUtils.toBean(item, RecheckTask2itemDO.class));
        }
        taskDO.setTaskStartTime(workReportVO.getTaskStartTime());
        taskDO.setTaskEndTime(workReportVO.getTaskEndTime());
        taskDO.setTaskExecutionDuration(workReportVO.getTaskExecutionDuration());
        taskDO.setActualStartTime(workReportVO.getTaskStartTime());
        taskDO.setActualEndTime(workReportVO.getTaskEndTime());
        taskDO.setActualExecutionDuration(workReportVO.getTaskExecutionDuration());
        taskDO.setAssigneerIds(workReportVO.getAssigneerIds());
        //这里需要处理名字，将名字拼起来
        if (workReportVO.getAssigneerIds() != null && workReportVO.getAssigneerIds().size() > 0) {
            List<String> names = new ArrayList<>();
            for (Long id : workReportVO.getAssigneerIds()) {
                AdminUserDO user = userService.getUser( id);
                names.add(user.getNickname());
            }
            taskDO.setAssigneerNames(String.join(",", names));
        }

        taskDO.setDescription(workReportVO.getDescription());
        taskDO.setIsCompleted(workReportVO.getIsCompleted());
        taskDO.setStatus(5);
        recheckTaskMapper.updateById(taskDO);

        RecheckTobeDO recheckTobe = selectRecheckTobeByTaskId(taskDO.getId());
        recheckTobe.setStatus(5);

        recheckTobeMapper.updateById(recheckTobe);

        return true;
    }


    public RecheckTobeDO selectRecheckTobeByTaskId(Long taskId) {
        return recheckTobeMapper.selectOne(new LambdaQueryWrapper<RecheckTobeDO>()
                .eq(RecheckTobeDO::getTaskId, taskId));
    }

}